{
 "cells": [
  {
   "cell_type": "code",
   "metadata": {
    "collapsed": true,
    "ExecuteTime": {
     "end_time": "2025-01-09T01:40:46.886441Z",
     "start_time": "2025-01-09T01:40:46.046541Z"
    }
   },
   "source": [
    "from sklearn.feature_extraction import DictVectorizer\n",
    "from sklearn.feature_extraction.text import CountVectorizer, TfidfVectorizer\n",
    "from sklearn.preprocessing import MinMaxScaler, StandardScaler\n",
    "from sklearn.feature_selection import VarianceThreshold\n",
    "from sklearn.decomposition import PCA\n",
    "import jieba\n",
    "import numpy as np\n",
    "from sklearn.impute import SimpleImputer"
   ],
   "outputs": [],
   "execution_count": 1
  },
  {
   "cell_type": "markdown",
   "source": [
    "# 1 特征中含有字符串的时候（当成类别），如何做特征抽取"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "source": [
    "\n",
    "def dictvec():\n",
    "    \"\"\"\n",
    "    字典数据抽取\n",
    "    :return: None\n",
    "    \"\"\"\n",
    "    # 实例化\n",
    "    # sparse改为True,输出的是每个不为零位置的坐标，稀疏矩阵可以节省存储空间\n",
    "    #矩阵中存在大量的0，sparse存储只记录非零位置，节省空间的作用\n",
    "    #Vectorizer中文含义是矢量器的含义\n",
    "    dict1 = DictVectorizer(sparse=True)  # 把sparse改为True看看\n",
    "\n",
    "    #每个样本都是一个字典，有三个样本\n",
    "    # 调用fit_transform\n",
    "    data = dict1.fit_transform([{'city': '北京', 'temperature': 100},\n",
    "                                {'city': '上海', 'temperature': 60},\n",
    "                                {'city': '深圳', 'temperature': 30}])\n",
    "    print(data)\n",
    "    print('-' * 50)\n",
    "    # 字典中的一些类别数据，分别进行转换成特征\n",
    "    print(dict1.get_feature_names_out())\n",
    "    print('-' * 50)\n",
    "    print(dict1.inverse_transform(data))  #去看每个特征代表的含义，逆转回去\n",
    "\n",
    "    return None\n",
    "\n",
    "\n",
    "dictvec()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-01-09T01:48:17.023797Z",
     "start_time": "2025-01-09T01:48:17.019302Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<Compressed Sparse Row sparse matrix of dtype 'float64'\n",
      "\twith 6 stored elements and shape (3, 4)>\n",
      "  Coords\tValues\n",
      "  (0, 1)\t1.0\n",
      "  (0, 3)\t100.0\n",
      "  (1, 0)\t1.0\n",
      "  (1, 3)\t60.0\n",
      "  (2, 2)\t1.0\n",
      "  (2, 3)\t30.0\n",
      "--------------------------------------------------\n",
      "['city=上海' 'city=北京' 'city=深圳' 'temperature']\n",
      "--------------------------------------------------\n",
      "[{'city=北京': 1.0, 'temperature': 100.0}, {'city=上海': 1.0, 'temperature': 60.0}, {'city=深圳': 1.0, 'temperature': 30.0}]\n"
     ]
    }
   ],
   "execution_count": 4
  },
  {
   "cell_type": "markdown",
   "source": [
    "# 2 一段英文文本如何变为数值类型"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "source": [
    "\n",
    "def couvec():\n",
    "    # 实例化CountVectorizer\n",
    "    # max_df, min_df整数：指每个词的所有文档词频数不小于最小值，出现该词的文档数目小于等于max_df\n",
    "    # max_df, min_df小数(0-1之间的）：某个词的出现的次数／所有文档数量\n",
    "    # min_df=2\n",
    "    # 默认会去除单个字母的单词，默认认为这个词对整个样本没有影响,认为其没有语义\n",
    "    vector = CountVectorizer(min_df=2)\n",
    "\n",
    "    # 调用fit_transform输入并转换数据\n",
    "\n",
    "    res = vector.fit_transform(\n",
    "        [\"life is  short,i like python life\",\n",
    "         \"life is too long,i dislike python\",\n",
    "         \"life is short\"])\n",
    "\n",
    "    # 打印结果,把每个词都分离了\n",
    "    print(vector.get_feature_names_out())\n",
    "    print('-' * 50)\n",
    "    print(res)\n",
    "    print('-' * 50)\n",
    "    print(type(res))\n",
    "    # 对照feature_names，标记每个词出现的次数\n",
    "    print('-' * 50)\n",
    "    print(res.toarray())  #稀疏矩阵转换为数组\n",
    "    print('-' * 50)\n",
    "    #拿每个样本里的特征进行显示\n",
    "    print(vector.inverse_transform(res))\n",
    "\n",
    "\n",
    "couvec()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-01-09T02:30:05.134563Z",
     "start_time": "2025-01-09T02:30:05.130184Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['is' 'life' 'python' 'short']\n",
      "--------------------------------------------------\n",
      "<Compressed Sparse Row sparse matrix of dtype 'int64'\n",
      "\twith 10 stored elements and shape (3, 4)>\n",
      "  Coords\tValues\n",
      "  (0, 1)\t2\n",
      "  (0, 0)\t1\n",
      "  (0, 3)\t1\n",
      "  (0, 2)\t1\n",
      "  (1, 1)\t1\n",
      "  (1, 0)\t1\n",
      "  (1, 2)\t1\n",
      "  (2, 1)\t1\n",
      "  (2, 0)\t1\n",
      "  (2, 3)\t1\n",
      "--------------------------------------------------\n",
      "<class 'scipy.sparse._csr.csr_matrix'>\n",
      "--------------------------------------------------\n",
      "[[1 2 1 1]\n",
      " [1 1 1 0]\n",
      " [1 1 0 1]]\n",
      "--------------------------------------------------\n",
      "[array(['life', 'is', 'short', 'python'], dtype='<U6'), array(['life', 'is', 'python'], dtype='<U6'), array(['life', 'is', 'short'], dtype='<U6')]\n"
     ]
    }
   ],
   "execution_count": 6
  },
  {
   "cell_type": "markdown",
   "source": [
    "# 一段汉字文本如何数值化，对于汉字不能用空格来分割"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "source": [
    "\n",
    "def countvec():\n",
    "    \"\"\"\n",
    "    对文本进行特征值化,单个汉字单个字母不统计，因为单个汉字字母没有意义\n",
    "    :return: None\n",
    "    \"\"\"\n",
    "    cv = CountVectorizer()\n",
    "\n",
    "    data = cv.fit_transform([\"人生苦短，我喜欢 python python\", \"人生漫长，不用 python\"])\n",
    "\n",
    "    print(cv.get_feature_names_out())\n",
    "    print('-' * 50)\n",
    "    print(data)  #稀疏存储，只记录非零位置\n",
    "    print('-' * 50)\n",
    "    print(data.toarray())\n",
    "\n",
    "    return None\n",
    "\n",
    "\n",
    "countvec()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-01-09T02:36:04.065279Z",
     "start_time": "2025-01-09T02:36:04.061632Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['python' '不用' '人生漫长' '人生苦短' '我喜欢']\n",
      "--------------------------------------------------\n",
      "<Compressed Sparse Row sparse matrix of dtype 'int64'\n",
      "\twith 6 stored elements and shape (2, 5)>\n",
      "  Coords\tValues\n",
      "  (0, 3)\t1\n",
      "  (0, 4)\t1\n",
      "  (0, 0)\t2\n",
      "  (1, 0)\t1\n",
      "  (1, 2)\t1\n",
      "  (1, 1)\t1\n",
      "--------------------------------------------------\n",
      "[[2 0 0 1 1]\n",
      " [1 1 1 0 0]]\n"
     ]
    }
   ],
   "execution_count": 8
  },
  {
   "cell_type": "markdown",
   "source": [
    "## 1.3 掌握如何对中文进行分词"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "source": [
    "\n",
    "def cutword():\n",
    "    \"\"\"\n",
    "    通过jieba对中文进行分词\n",
    "    :return:\n",
    "    \"\"\"\n",
    "    con1 = jieba.cut(\"今天很残酷，明天更残酷，后天很美好，但绝对大部分是死在明天晚上，所以每个人不要放弃今天。\")\n",
    "\n",
    "    con2 = jieba.cut(\"我们看到的从很远星系来的光是在几百万年之前发出的，这样当我们看到宇宙时，我们是在看它的过去。\")\n",
    "\n",
    "    con3 = jieba.cut(\n",
    "        \"如果只用一种方式了解某样事物，你就不会真正了解它。了解事物真正含义的秘密取决于如何将其与我们所了解的事物相联系。\")\n",
    "\n",
    "    # 转换成列表\n",
    "    print(type(con1))\n",
    "    print('-' * 50)\n",
    "    # 把生成器转换成列表\n",
    "    content1 = list(con1)\n",
    "    content2 = list(con2)\n",
    "    content3 = list(con3)\n",
    "    print(content1)\n",
    "    print(content2)\n",
    "    print(content3)\n",
    "    # 把列表转换成字符串,每个词之间用空格隔开\n",
    "    print('-' * 50)\n",
    "    c1 = ' '.join(content1)\n",
    "    c2 = ' '.join(content2)\n",
    "    c3 = ' '.join(content3)\n",
    "\n",
    "    return c1, c2, c3\n",
    "\n",
    "\n",
    "def hanzivec():\n",
    "    \"\"\"\n",
    "    中文特征值化\n",
    "    :return: None\n",
    "    \"\"\"\n",
    "    c1, c2, c3 = cutword()  #jieba分词好的中文文本\n",
    "    print('-' * 50)\n",
    "    print(c1)  #把分词好的文本打印出来\n",
    "    print(c2)\n",
    "    print(c3)\n",
    "    print('-' * 50)\n",
    "\n",
    "    cv = CountVectorizer()\n",
    "\n",
    "    data = cv.fit_transform([c1, c2, c3])\n",
    "\n",
    "    print(cv.get_feature_names_out())  #把处理好后的特征名称打印出来\n",
    "\n",
    "    print(data.toarray())\n",
    "\n",
    "    return None\n",
    "\n",
    "\n",
    "# cutword()\n",
    "hanzivec()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-01-09T02:45:58.952934Z",
     "start_time": "2025-01-09T02:45:58.946994Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'generator'>\n",
      "--------------------------------------------------\n",
      "['今天', '很', '残酷', '，', '明天', '更', '残酷', '，', '后天', '很', '美好', '，', '但', '绝对', '大部分', '是', '死', '在', '明天', '晚上', '，', '所以', '每个', '人', '不要', '放弃', '今天', '。']\n",
      "['我们', '看到', '的', '从', '很', '远', '星系', '来', '的', '光是在', '几百万年', '之前', '发出', '的', '，', '这样', '当', '我们', '看到', '宇宙', '时', '，', '我们', '是', '在', '看', '它', '的', '过去', '。']\n",
      "['如果', '只用', '一种', '方式', '了解', '某样', '事物', '，', '你', '就', '不会', '真正', '了解', '它', '。', '了解', '事物', '真正', '含义', '的', '秘密', '取决于', '如何', '将', '其', '与', '我们', '所', '了解', '的', '事物', '相', '联系', '。']\n",
      "--------------------------------------------------\n",
      "--------------------------------------------------\n",
      "今天 很 残酷 ， 明天 更 残酷 ， 后天 很 美好 ， 但 绝对 大部分 是 死 在 明天 晚上 ， 所以 每个 人 不要 放弃 今天 。\n",
      "我们 看到 的 从 很 远 星系 来 的 光是在 几百万年 之前 发出 的 ， 这样 当 我们 看到 宇宙 时 ， 我们 是 在 看 它 的 过去 。\n",
      "如果 只用 一种 方式 了解 某样 事物 ， 你 就 不会 真正 了解 它 。 了解 事物 真正 含义 的 秘密 取决于 如何 将 其 与 我们 所 了解 的 事物 相 联系 。\n",
      "--------------------------------------------------\n",
      "['一种' '不会' '不要' '之前' '了解' '事物' '今天' '光是在' '几百万年' '发出' '取决于' '只用' '后天' '含义'\n",
      " '大部分' '如何' '如果' '宇宙' '我们' '所以' '放弃' '方式' '明天' '星系' '晚上' '某样' '残酷' '每个'\n",
      " '看到' '真正' '秘密' '绝对' '美好' '联系' '过去' '这样']\n",
      "[[0 0 1 0 0 0 2 0 0 0 0 0 1 0 1 0 0 0 0 1 1 0 2 0 1 0 2 1 0 0 0 1 1 0 0 0]\n",
      " [0 0 0 1 0 0 0 1 1 1 0 0 0 0 0 0 0 1 3 0 0 0 0 1 0 0 0 0 2 0 0 0 0 0 1 1]\n",
      " [1 1 0 0 4 3 0 0 0 0 1 1 0 1 0 1 1 0 1 0 0 1 0 0 0 1 0 0 0 2 1 0 0 1 0 0]]\n"
     ]
    }
   ],
   "execution_count": 10
  },
  {
   "cell_type": "markdown",
   "source": [
    "# 1.4 tf-idf"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "source": [
    "# 规范{'l1'，'l2'}，默认='l2'\n",
    "# 每个输出行都有单位范数，或者：\n",
    "#\n",
    "# 'l2'：向量元素的平方和为 1。当应用 l2 范数时，两个向量之间的余弦相似度是它们的点积。\n",
    "#\n",
    "# 'l1'：向量元素的绝对值之和为 1。参见preprocessing.normalize。\n",
    "\n",
    "# smooth_idf布尔值，默认 = True\n",
    "# 通过在文档频率上加一来平滑 idf 权重，就好像看到一个额外的文档包含集合中的每个术语恰好一次。防止零分裂。\n",
    "# 比如训练集中有某个词，测试集中没有，就是生僻词，就会造成n(x)分母为零，log(n/n(x)),从而出现零分裂\n",
    "\n",
    "def tfidfvec():\n",
    "    \"\"\"\n",
    "    中文特征值化,计算tfidf值\n",
    "    :return: None\n",
    "    \"\"\"\n",
    "    c1, c2, c3 = cutword()\n",
    "\n",
    "    print(c1, c2, c3)\n",
    "    # print(type([c1, c2, c3]))\n",
    "    tf = TfidfVectorizer(smooth_idf=True)\n",
    "\n",
    "    data = tf.fit_transform([c1, c2, c3])\n",
    "\n",
    "    print(tf.get_feature_names_out())\n",
    "    print('-' * 50)\n",
    "    print(type(data))\n",
    "    print('-' * 50)\n",
    "    print(data.toarray())\n",
    "\n",
    "    return None\n",
    "\n",
    "\n",
    "tfidfvec()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-01-09T02:54:12.603445Z",
     "start_time": "2025-01-09T02:54:12.597915Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'generator'>\n",
      "--------------------------------------------------\n",
      "['今天', '很', '残酷', '，', '明天', '更', '残酷', '，', '后天', '很', '美好', '，', '但', '绝对', '大部分', '是', '死', '在', '明天', '晚上', '，', '所以', '每个', '人', '不要', '放弃', '今天', '。']\n",
      "['我们', '看到', '的', '从', '很', '远', '星系', '来', '的', '光是在', '几百万年', '之前', '发出', '的', '，', '这样', '当', '我们', '看到', '宇宙', '时', '，', '我们', '是', '在', '看', '它', '的', '过去', '。']\n",
      "['如果', '只用', '一种', '方式', '了解', '某样', '事物', '，', '你', '就', '不会', '真正', '了解', '它', '。', '了解', '事物', '真正', '含义', '的', '秘密', '取决于', '如何', '将', '其', '与', '我们', '所', '了解', '的', '事物', '相', '联系', '。']\n",
      "--------------------------------------------------\n",
      "今天 很 残酷 ， 明天 更 残酷 ， 后天 很 美好 ， 但 绝对 大部分 是 死 在 明天 晚上 ， 所以 每个 人 不要 放弃 今天 。 我们 看到 的 从 很 远 星系 来 的 光是在 几百万年 之前 发出 的 ， 这样 当 我们 看到 宇宙 时 ， 我们 是 在 看 它 的 过去 。 如果 只用 一种 方式 了解 某样 事物 ， 你 就 不会 真正 了解 它 。 了解 事物 真正 含义 的 秘密 取决于 如何 将 其 与 我们 所 了解 的 事物 相 联系 。\n",
      "['一种' '不会' '不要' '之前' '了解' '事物' '今天' '光是在' '几百万年' '发出' '取决于' '只用' '后天' '含义'\n",
      " '大部分' '如何' '如果' '宇宙' '我们' '所以' '放弃' '方式' '明天' '星系' '晚上' '某样' '残酷' '每个'\n",
      " '看到' '真正' '秘密' '绝对' '美好' '联系' '过去' '这样']\n",
      "--------------------------------------------------\n",
      "<class 'scipy.sparse._csr.csr_matrix'>\n",
      "--------------------------------------------------\n",
      "[[0.         0.         0.21821789 0.         0.         0.\n",
      "  0.43643578 0.         0.         0.         0.         0.\n",
      "  0.21821789 0.         0.21821789 0.         0.         0.\n",
      "  0.         0.21821789 0.21821789 0.         0.43643578 0.\n",
      "  0.21821789 0.         0.43643578 0.21821789 0.         0.\n",
      "  0.         0.21821789 0.21821789 0.         0.         0.        ]\n",
      " [0.         0.         0.         0.2410822  0.         0.\n",
      "  0.         0.2410822  0.2410822  0.2410822  0.         0.\n",
      "  0.         0.         0.         0.         0.         0.2410822\n",
      "  0.55004769 0.         0.         0.         0.         0.2410822\n",
      "  0.         0.         0.         0.         0.48216441 0.\n",
      "  0.         0.         0.         0.         0.2410822  0.2410822 ]\n",
      " [0.15698297 0.15698297 0.         0.         0.62793188 0.47094891\n",
      "  0.         0.         0.         0.         0.15698297 0.15698297\n",
      "  0.         0.15698297 0.         0.15698297 0.15698297 0.\n",
      "  0.1193896  0.         0.         0.15698297 0.         0.\n",
      "  0.         0.15698297 0.         0.         0.         0.31396594\n",
      "  0.15698297 0.         0.         0.15698297 0.         0.        ]]\n"
     ]
    }
   ],
   "execution_count": 11
  },
  {
   "cell_type": "markdown",
   "source": [
    "# 2 特征处理，不同的特征拉到到同一个量纲"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "source": [
    "def mm():\n",
    "    \"\"\"\n",
    "    归一化处理\n",
    "    :return: NOne\n",
    "    \"\"\"\n",
    "    # 归一化缺点 容易受极值的影响\n",
    "    #feature_range代表特征值范围，一般设置为(0,1),或者(-1,1),默认是(0,1)\n",
    "    mm = MinMaxScaler(feature_range=(0, 1))\n",
    "\n",
    "    data = mm.fit_transform([[90, 2, 10, 40], [60, 4, 15, 45], [75, 3, 13, 46]])\n",
    "\n",
    "    print(data)\n",
    "    print('-' * 50)\n",
    "    out = mm.transform([[1, 2, 3, 4], [6, 5, 8, 7]])\n",
    "    print(out)\n",
    "    return None\n",
    "    #transform和fit_transform不同是，transform用于测试集，而且不会重新找最小值和最大值\n",
    "\n",
    "\n",
    "mm()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-01-09T03:12:14.389285Z",
     "start_time": "2025-01-09T03:12:14.385450Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1.         0.         0.         0.        ]\n",
      " [0.         1.         1.         0.83333333]\n",
      " [0.5        0.5        0.6        1.        ]]\n",
      "--------------------------------------------------\n",
      "[[-1.96666667  0.         -1.4        -6.        ]\n",
      " [-1.8         1.5        -0.4        -5.5       ]]\n"
     ]
    }
   ],
   "execution_count": 15
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "outputs": [
    {
     "data": {
      "text/plain": "-1.9666666666666666"
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": "(1 - 60) / 30",
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-07-11T01:56:23.103848700Z",
     "start_time": "2024-07-11T01:56:23.052804200Z"
    }
   }
  },
  {
   "cell_type": "code",
   "source": [
    "def stand():\n",
    "    \"\"\"\n",
    "    标准化缩放，不是标准正太分布，只均值为0，方差为1的分布\n",
    "    :return:\n",
    "    \"\"\"\n",
    "    std = StandardScaler()\n",
    "\n",
    "    data = std.fit_transform([[1., -1., 3.],\n",
    "                              [2., 4., 2.],\n",
    "                              [4., 6., -1.]])\n",
    "\n",
    "    print(data)\n",
    "    print('-' * 50)\n",
    "    print(std.mean_)\n",
    "    print('-' * 50)\n",
    "    print(std.var_)  #方差\n",
    "    print(std.n_samples_seen_)  # 样本数\n",
    "    return data\n",
    "\n",
    "\n",
    "data = stand()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-01-09T03:19:52.727022Z",
     "start_time": "2025-01-09T03:19:52.723484Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[-1.06904497 -1.35873244  0.98058068]\n",
      " [-0.26726124  0.33968311  0.39223227]\n",
      " [ 1.33630621  1.01904933 -1.37281295]]\n",
      "--------------------------------------------------\n",
      "[2.33333333 3.         1.33333333]\n",
      "--------------------------------------------------\n",
      "[1.55555556 8.66666667 2.88888889]\n",
      "3\n"
     ]
    }
   ],
   "execution_count": 20
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-09T06:08:50.094350Z",
     "start_time": "2025-01-09T06:08:50.091180Z"
    }
   },
   "cell_type": "code",
   "source": [
    "#如何求方差\n",
    "(np.square(1 - 2.333) + np.square(2 - 2.333) + np.square(4 - 2.333)) / 3"
   ],
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.5555556666666668"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 24
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "outputs": [
    {
     "data": {
      "text/plain": "numpy.ndarray"
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(data)"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-07-11T02:18:33.954581900Z",
     "start_time": "2024-07-11T02:18:33.940452300Z"
    }
   }
  },
  {
   "cell_type": "code",
   "source": [
    "std1 = StandardScaler()\n",
    "#为了证明上面输出的结果的均值是为0的，方差为1\n",
    "data1 = std1.fit_transform([[-1.06904497, -1.35873244, 0.98058068],\n",
    "                            [-0.26726124, 0.33968311, 0.39223227],\n",
    "                            [1.33630621, 1.01904933, -1.37281295]])\n",
    "# print(data1)  #这个并不是我们想看的，没意义\n",
    "# 均值\n",
    "print(std1.mean_)\n",
    "# 方差\n",
    "print(std1.var_)"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-01-09T03:23:04.130844Z",
     "start_time": "2025-01-09T03:23:04.127661Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0. 0. 0.]\n",
      "[1.         1.         1.00000001]\n"
     ]
    }
   ],
   "execution_count": 22
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "outputs": [
    {
     "data": {
      "text/plain": "1.5555556666666668"
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": "(np.square(1 - 2.333) + np.square(2 - 2.333) + np.square(4 - 2.333)) / 3",
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-04-16T03:27:52.239803100Z",
     "start_time": "2024-04-16T03:27:52.199808400Z"
    }
   }
  },
  {
   "cell_type": "code",
   "source": "(1 - 2.333) / np.sqrt(1.55555)",
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-01-09T06:17:18.212483Z",
     "start_time": "2025-01-09T06:17:18.208598Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-1.068779614944516"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 25
  },
  {
   "cell_type": "markdown",
   "source": [
    "## transform和fit_transform不同是，transform用于测试集，而且不会重新找最小值和最大值,不会重新计算均值方差"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "# 3 缺失值处理\n"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "source": [
    "#下面是填补，针对删除，可以用pd和np\n",
    "def im():\n",
    "    \"\"\"\n",
    "    缺失值处理\n",
    "    :return:None\n",
    "    \"\"\"\n",
    "    # NaN, nan,缺失值必须是这种形式，如果是？号(或者其他符号)，就要replace换成这种\n",
    "    #mean, median, most_frequent(众数), constant\n",
    "    im = SimpleImputer(missing_values=np.nan, strategy='mean')\n",
    "\n",
    "    data = im.fit_transform([[1, 2], [np.nan, 3], [7, 6], [3, 2]])\n",
    "\n",
    "    print(data)\n",
    "\n",
    "    return None\n",
    "\n",
    "\n",
    "im()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-01-09T12:55:28.457006Z",
     "start_time": "2025-01-09T12:55:28.448123Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1.         2.        ]\n",
      " [3.66666667 3.        ]\n",
      " [7.         6.        ]\n",
      " [3.         2.        ]]\n"
     ]
    }
   ],
   "execution_count": 38
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "outputs": [
    {
     "data": {
      "text/plain": "3.6666666666666665"
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": "11 / 3",
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-07-11T02:22:34.367453500Z",
     "start_time": "2024-07-11T02:22:34.322497700Z"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "outputs": [
    {
     "data": {
      "text/plain": "nan"
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": "np.nan + 10",
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-07-11T02:23:44.133095700Z",
     "start_time": "2024-07-11T02:23:44.114673600Z"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "# 4 降维\n",
    "# 降维就是特征数变少\n",
    "# 降维可以提高模型训练速度（特征变少）"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "source": [
    "def var():\n",
    "    \"\"\"\n",
    "    特征选择-删除低方差的特征\n",
    "    :return: None\n",
    "    \"\"\"\n",
    "    #默认只删除方差为0,threshold是方差阈值，删除比这个值小的那些特征\n",
    "    var = VarianceThreshold(threshold=0.1)\n",
    "\n",
    "    data = var.fit_transform([[0, 2, 0, 3],\n",
    "                              [0, 1, 4, 3],\n",
    "                              [0, 1, 1, 3]])\n",
    "\n",
    "    print(data)\n",
    "    print('-' * 50)\n",
    "    # 获得剩余的特征的列编号\n",
    "    print('The surport is %s' % var.get_support(True))\n",
    "    return None\n",
    "\n",
    "\n",
    "var()\n"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-01-09T06:30:29.502457Z",
     "start_time": "2025-01-09T06:30:29.498953Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[2 0]\n",
      " [1 4]\n",
      " [1 1]]\n",
      "--------------------------------------------------\n",
      "The surport is [1 2]\n"
     ]
    }
   ],
   "execution_count": 30
  },
  {
   "cell_type": "code",
   "source": [
    "def pca():\n",
    "    \"\"\"\n",
    "    主成分分析进行特征降维\n",
    "    :return: None\n",
    "    \"\"\"\n",
    "    # n_ components:小数 0~1 90% 业界选择 90~95%\n",
    "\n",
    "    # 当n_components的值为0到1之间的浮点数时，表示我们希望保留的主成分解释的方差比例。方差比例是指 得到输出的每一列的方差值和除以原有数据方差之和。\n",
    "    # 具体而言，n_components=0.9表示我们希望选择足够的主成分，以使它们解释数据方差的90%。\n",
    "\n",
    "    # n_components如果是整数   减少到的特征数量\n",
    "    # 原始数据方差\n",
    "    original_value = np.array([[2, 8, 4, 5],\n",
    "                               [6, 3, 0, 8],\n",
    "                               [5, 4, 9, 1]])\n",
    "    print(np.var(original_value, axis=0).sum())  #最初数据每一列的方差，求和\n",
    "    print('-' * 50)\n",
    "    pca = PCA(n_components=0.99)\n",
    "\n",
    "    data = pca.fit_transform(original_value)\n",
    "\n",
    "    print(data)\n",
    "    print(type(data))\n",
    "    #计算data的方差和\n",
    "    print(np.var(data, axis=0).sum())\n",
    "    print('-' * 50)\n",
    "    print(pca.explained_variance_ratio_)\n",
    "    # 计算data的方差占总方差的比例\n",
    "    print(pca.explained_variance_ratio_.sum())\n",
    "\n",
    "    return None\n",
    "\n",
    "\n",
    "pca()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-01-09T06:58:15.573023Z",
     "start_time": "2025-01-09T06:58:15.568373Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "29.333333333333336\n",
      "--------------------------------------------------\n",
      "[[-1.28620952e-15  3.82970843e+00]\n",
      " [-5.74456265e+00 -1.91485422e+00]\n",
      " [ 5.74456265e+00 -1.91485422e+00]]\n",
      "<class 'numpy.ndarray'>\n",
      "29.333333333333332\n",
      "--------------------------------------------------\n",
      "[0.75 0.25]\n",
      "1.0\n"
     ]
    }
   ],
   "execution_count": 35
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "outputs": [
    {
     "data": {
      "text/plain": "0.7499999999999999"
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": "22 / 29.333333333333336",
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-07-11T03:08:17.259124100Z",
     "start_time": "2024-07-11T03:08:17.248038900Z"
    }
   }
  },
  {
   "cell_type": "code",
   "source": [
    "from matplotlib import pyplot as plt\n",
    "\n",
    "x = np.random.rand(10000)  #每个的概率\n",
    "t = np.arange(len(x))\n",
    "plt.plot(t, x, 'g.', label=\"Uniform Distribution\")\n",
    "plt.legend(loc=\"upper left\")\n",
    "plt.grid()\n",
    "plt.show()"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-01-09T07:00:20.683120Z",
     "start_time": "2025-01-09T07:00:19.634271Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ],
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "execution_count": 36
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}
